home *** CD-ROM | disk | FTP | other *** search
/ MacWorld 1997 September / Macworld (1997-09).dmg / Serious Software / Cherwell Scientific Demos / pro Fit / pro Fit 5.0 demo (fpu).sea / pro Fit 5.0 demo (fpu) / External Modules / External modules sources / C / Inverse erf.c < prev    next >
Text File  |  1996-04-21  |  7KB  |  178 lines
  1. /***************************************************************************************/
  2. /* ErrorFunction.c                                                                  */
  3. /*                                                                                     */
  4. /* Version 25.9.94                                                                     */
  5. /***************************************************************************************/
  6.  
  7.  
  8. #include "proFit_interface.h"
  9. #include <math.h>
  10.  
  11. #define Inf HUGE_VAL
  12.  
  13.  
  14.  
  15. /***************************************************************************************/
  16.  
  17. void SetUp (    short* const moduleKind,        /* set moduleKind to isFunction or isProgram */
  18.                 Str255 name,                    /* the name of the program or function (pascal string) */
  19.                 long* const requiredGlobals,    /* the number of bytes to be allocated in ExtModulesParamBlock.globals */
  20.                                                 /* set requiredGlobals to 0 if you don't use this feature */
  21.                 ExtModulesParamBlock* pb)        /* the complete parameter block passed by pro Fit to the */
  22.                                                 /* routines defined in this file. In most cases it can be ignored */
  23. /* SetUp is called once when the external module is linked to proFit */
  24. {
  25.     *moduleKind=isFunction;                        /* we define a function */
  26.     SetPascalStr(name,"\pInverse erf",255);        /* with the name "Inverse erf" */
  27.     *requiredGlobals=0;                            /* we define no globals */
  28. }
  29.  
  30. /***************************************************************************************/
  31.  
  32. void InitializeFunc (
  33.                 Boolean* const hasDerivatives,    /* set this to true if and only if you define the function */
  34.                                                 /* Derivatives to calculate the partial derivatives of the parameters */
  35.                 Str255 descr1stLine,            /* first line of the text in the parameter window */
  36.                 Str255 descr2ndLine,            /* second line of the text in the parameter window */
  37.                 short* const numberOfParams,    /* the number of parameters of the function */
  38.                 DefaultParamInfo* const a0,        /* the default names, values etc. of the parameters */
  39.                 ExtModulesParamBlock* pb)        /* the complete parameter block passed by pro Fit to the */
  40.                                                 /* routines defined in this file. In most cases it can be ignored */
  41. /* InitializeFunc is called once (after SetUp has been called) when the external module is linked to proFit */
  42. /* Used to set all the information needed to describe a function */
  43. {    
  44.     *hasDerivatives=false;
  45.     SetPascalStr(descr1stLine,"\pThe inverse of the error function.",255);
  46.     SetPascalStr(descr2ndLine,"\py := A*InvErf(x-x0) + const",255);
  47.  
  48.     *numberOfParams=3;                            /* we have 3 parameters */
  49.     
  50. /* The following is to set parameter names, fitting modes, etc. */
  51.  
  52.     (*a0->value)[0] = 1.0;                        /* set their names and defaults    */
  53.     (*a0->mode)[0] = inactive;
  54.     SetPascalStr((*a0->name)[0],"\pA",  maxParamNameLength);
  55.  
  56.     (*a0->value)[1]= 0.0;
  57.     (*a0->mode)[1] = inactive;
  58.     SetPascalStr((*a0->name)[1],"\px0", maxParamNameLength);
  59.     
  60.     (*a0->value)[2]= 0.0;
  61.     (*a0->mode)[2] = inactive;
  62.     SetPascalStr((*a0->name)[2],"\pconst",maxParamNameLength);
  63.     
  64. }
  65.  
  66. /***************************************************************************************/
  67.  
  68. short Check(short paramNo,                        /* the parameter that was changed */
  69.                 DefaultParamInfo* const a0,        /* the default names, values etc of the paramters */
  70.                 ExtModulesParamBlock* pb)        /* the complete parameter block passed by pro Fit to the */
  71.                                                 /* routines defined in this file. In most cases it can be ignored */
  72.     /* Can be left emtpy (returning good) if not needed. */
  73.     /* called when the user has changed a value in the parameters window. This routine */
  74.     /* can then check if this parameters is fine. It can also change some of the */
  75.     /* other entries in a0. The returned values can be: */
  76.     /*    good:        return this value if you agree with the new parameter value */
  77.     /*    update:        return this value if you want the parameters window */
  78.     /*                to be updated because you changed some of the values in a0 */
  79.     /*    bad:        return this value if you want the new parameter value to be refused */
  80. {
  81.     return good;    /* we have nothing to do here */
  82.  
  83. }
  84.  
  85. /***************************************************************************************/
  86.  
  87. void First (    ParamArray a,                /* the new parameters */
  88.                 ExtModulesParamBlock* pb)    /* the complete parameter block passed by pro Fit to the */
  89.                                             /* routines defined in this file. In most cases it can be ignored */
  90.     /* Can be left emtpy if not needed. */
  91.     /* Called whenever the parameters are changed. Can be used to accelerate */
  92.     /* some calculations. See manual for more info */
  93. {
  94. }
  95. /***************************************************************************************/
  96.  
  97.  
  98. static double InvErf(double x)
  99.     // returns the inverse of the error function
  100.     // accuracy better than 1e-7
  101.     // this function was inspired by A.J. Strecok, math. comp. 1968, page 144ff
  102.     // accuracy between -0.999 and 0.999: better than 10E-7
  103.     // (C) 1996 QuantumSoft
  104. {
  105.     double    y;
  106.  
  107.     y = sqrt(-log(1.0-x*x));
  108.  
  109.     y = y * (0.6374868939151371 + y*(-0.2767067324742911 + y*
  110.             (0.1503581502062744 + y * (-2.5878691411691874e-2 + y * 9.7670209741420530e-3)))) /
  111.             (0.7193322618853618 + y*(-0.3122885268724753 + y*
  112.             (0.1614016565020622 + y * (-2.5947254488147567e-2 + y * 9.7832443176615724e-3))));
  113.  
  114.     if (x<0) y *= -1;
  115.     return y;
  116. }
  117.  
  118. void Func (        double x,                        /* the x-value */
  119.                 ParamArray a,                    /* the parameters */
  120.                 double* const y,                /* the y-value to be returned */
  121.                 ExtModulesParamBlock* pb)        /* the complete parameter block passed by pro Fit to the */
  122.                                                 /* routines defined in this file. In most cases it can be ignored */
  123.     /* called to calculate the y-value of the function for a given x and a given */
  124.     /* set of parameters */
  125. {
  126.     *y = a[0]*InvErf(x-a[1]) + a[2];
  127. }
  128.  
  129. /***************************************************************************************/
  130.  
  131. void Derivatives(double x,                        /* the x-value */
  132.                 ParamArray a,                    /* the parameters */
  133.                 ParamArray dyda,                /* the derivatives to be returned */
  134.                 ExtModulesParamBlock* pb)        /* the complete parameter block passed by pro Fit to the */
  135.                                                 /* routines defined in this file. In most cases it can be ignored */
  136.     /* Can be left empty if InitializeFunc sets hasDerivatives to false */
  137.     /* called to calculate the partial derivatives of the function with respect to */
  138.     /* its parameters. If you leave this function empty and set hasDerivatives to false in */
  139.     /* FuncInitialize, the derivatives will be calcuated numerically, otherwise pro Fit */
  140.     /* calls this function to obtain the values of ALL derivatives. */
  141.     /* As a result of the numerical calculation fitting will be slower */
  142. {
  143. }
  144.  
  145.  
  146.  
  147. /***************************************************************************************/
  148.  
  149. void Last (ExtModulesParamBlock* pb)
  150.     /* Can be left emtpy if not needed. */
  151.     /* Called when calculating is through. See manual for more info */
  152. {
  153. }
  154.  
  155. /***************************************************************************************/
  156.  
  157. void CleanUp (ExtModulesParamBlock* pb)
  158.     /* called when the external module is removed from pro Fit's menus */
  159.     /* in most cases, this function can be empty */
  160. {
  161. }
  162.  
  163.  
  164.  
  165.  
  166.  
  167. /***************************************************************************************/
  168.                         /* for programs, not used here: */
  169. /***************************************************************************************/
  170.  
  171. void InitializeProg (ExtModulesParamBlock* pb)
  172. {}
  173.  
  174. void Run(ExtModulesParamBlock* pb)
  175. {}
  176.  
  177.  
  178.